home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1994 / MacHack 1994.toast / MacHack™94 / Talks & Papers / Timothy Knox / yerk 3.66 / Asm source / ic1 < prev    next >
Text File  |  1994-06-24  |  7KB  |  455 lines
  1. \ Instruction Classes            Reese Warner                    3/85
  2. \        8/85    RW     added comments
  3. \        8/85    RW     Added Yerk mode
  4. \        9/85    RW     Added type 26, sized single ea instruction
  5. \        9/85    RW     Added type27, for the STOP instruction
  6. \        12/85    JF     Fixed LENGTH: method on TYPE3
  7. \    03/07/86    GDC     Fixed type 7 BUILD:
  8. \    7/10/86     mrh    Fixed type 6, for short branches
  9. \   1/16/94    rfl        Fixed type4...srcmask changed to dstmask; type9 ala mrh
  10.  
  11. 0 -> dlevel
  12.  
  13. :CLASS machInst <super object
  14.  
  15.     var bytecode
  16.     int srcMask
  17.     int dstMask
  18.     int theSize
  19.  
  20. :M INIT:    { opcode -- }
  21.     opcode put: bytecode
  22.     hex
  23.     @word number drop put: srcMask        \ reads sourcemask
  24.     @word number drop put: dstMask        \ reads destination mask
  25.     @word number drop put: theSize        \ reads the machine code size
  26.     decimal
  27. ;M
  28.  
  29. :M BC:    \ debug
  30.     binary get: bytecode ." bytecode is " u. cr decimal
  31. ;M
  32.  
  33. :M MASKS:    \ debug
  34.     hex get: srcMask ." src is " u. cr
  35.     get: dstMask ." dst is " u. cr
  36. ;M
  37.  
  38. :M OPSIZE:
  39.     get: theSize
  40. ;M
  41.  
  42. ;CLASS
  43.  
  44. \ TYPE1 - No operand instructions, such as Reset, Stop, etc.
  45. :CLASS type1 <super machInst
  46.  
  47. :M BUILD:
  48.     get: bytecode w,
  49. ;M
  50.  
  51. :M LENGTH: ( -- len )
  52.     1
  53. ;M
  54.  
  55. ;CLASS
  56.  
  57. \ TYPE2 - Register, immediate value, such as Link
  58. \    e.g. Link A0,#100
  59. :CLASS type2 <super machInst
  60.  
  61. :M BUILD:    { \ workSpace -- }
  62.     op1 getOp
  63.     get: bytecode -> workSpace
  64.     workSpace reg: op1 or w,
  65.     op2 getOp
  66.     value: op2 w,
  67. ;M
  68.  
  69. :M LENGTH: ( -- len )
  70.     op1 getOp
  71.     op1 get: srcMask check
  72.     op2 getOp
  73.     op2 get: dstMask check
  74.     2
  75. ;M
  76.  
  77. ;CLASS
  78.  
  79. \ TYPE3 - Instructions that take an immediate operand, such as ANDI, EORI
  80. \    e.g. EORI.W #100,-(A4)
  81. :CLASS type3 <super machInst
  82.  
  83. :M BUILD:    { \ workSpace -- }
  84.     op1 getOp
  85.     op2 getOp
  86.     get: bytecode -> workSpace
  87.     opSize 6 << workSpace or -> workSpace
  88.     ea: op2 workspace or -> workSpace
  89.     workSpace w,
  90.     value: op1        \ immediate Data
  91.     opSize 2 =
  92.     IF
  93.         ,
  94.     ELSE
  95.         w,
  96.     THEN
  97.     op2 compIdxMode
  98. ;M
  99.  
  100. :M LENGTH:    { \ size -- len }
  101.     op1 getOp
  102.     op1 get: srcMask check
  103.     op2 getOp
  104.     op2 get: dstMask check
  105.     2 -> size        \ 1 -> 2 jaf 12/17
  106.     op2 modeSize ++> size
  107.     opSize 1- 0 max ++> size    \ '1 max' -> '1- 0 max' jaf 12/17
  108.     size
  109. ;M
  110.  
  111. ;CLASS
  112.  
  113. \ TYPE4 - Instructions that take a reg, an effective Addr, an opmode
  114. \    e.g. OR.L d0,(SP), ADD
  115. :CLASS type4 <super machInst
  116.  
  117. :M BUILD:    { \ opMode Reg EA workSpace flag -- }
  118.     op1 getOp
  119.     op2 getOp
  120.     true -> flag
  121.     mode: op2 1 =
  122.     IF
  123.         opSize 2 =
  124.         IF
  125.             7 -> opMode
  126.         ELSE
  127.             3 -> opMode
  128.         THEN
  129.         reg: op2 -> reg
  130.         ea: op1 -> ea
  131.         false -> flag
  132.     THEN
  133.     mode: op2 0= flag and 
  134.     get: srcMask 1 <> and         \ Don't let EOR Dm,Dn come here - MRH
  135.     IF
  136.         opSize -> opMode
  137.         reg: op2 -> reg
  138.         ea: op1 -> ea
  139.         false -> flag
  140.     THEN
  141.     mode: op1 0= flag and
  142.     IF
  143.         opSize 4+ -> opMode
  144.         reg: op1 -> reg
  145.         ea: op2 -> ea
  146.         false -> flag
  147.     THEN
  148.     flag
  149.     IF
  150.         219 asmERROR    \ at least one operand must be a register direct
  151.     THEN
  152.     get: bytecode -> workSpace
  153.     reg 9 << workSpace or -> workspace
  154.     opMode 6 << workSpace or -> workSpace
  155.     ea workSpace or -> workSpace
  156.     workSpace w,
  157.     op1 compIdxMode
  158.     op2 compIdxMode
  159. ;M
  160.  
  161. :M LENGTH:    { \ len -- len }
  162.     op1 getOp
  163.     op1 get: srcMask check
  164.     op2 getOp
  165.     op2 get: dstMask check
  166.     1 -> len
  167.     op1 modesize ++> len
  168.     op2 modesize ++> len
  169.     len
  170. ;M
  171.  
  172. ;CLASS
  173.  
  174. \ TYPE5 - reg & ea, unsized e.g. LEA -(A4),A3
  175. :CLASS type5 <super machInst
  176.  
  177. :M BUILD:    { \ workSpace -- }
  178.     op1 getOp
  179.     op2 getOp
  180.     get: bytecode -> workSpace
  181.     reg: op2 9 << workSpace or -> workSpace
  182.     ea: op1 workSpace or -> workSpace
  183.     workSpace w,
  184.     op1 compIdxMode
  185. ;M
  186.  
  187. :M LENGTH:    ( -- len )
  188.     op1 getOp
  189.     op1 get: srcMask check
  190.     op2 getOp
  191.     op2 get: dstMask check
  192.     1 op1 modeSize +
  193. ;M
  194.  
  195. ;CLASS
  196.  
  197. \ TYPE6 - Branch Instructions
  198. \    e.g. BNE aLabel
  199. :CLASS type6 <super machInst
  200.  
  201. :M BUILD:
  202.     op1 getOp
  203.     get: bytecode value: op1
  204.     opSize 0=
  205.     IF    dup 127 > over -128 < or
  206.         IF 250 asmerror THEN    $ ff and or
  207.     ELSE swap w,
  208.     THEN w,
  209. ;M
  210.  
  211. :M LENGTH:
  212.     op1 getOp
  213.     op1 get: srcMask check
  214.     opSize IF 2 ELSE 1 THEN
  215. ;M
  216.  
  217. ;CLASS
  218.  
  219. \ TYPE7 - Bit test operations: BCLR,BSET,BTST,BCHG
  220. \    e.g. BTST D5,-(A4) or BTST #5,-(A4)
  221. :CLASS type7 <super machInst
  222.  
  223. :M BUILD:    { \ workSpace -- }
  224.     op1 getOp
  225.     op2 getOp
  226.     get: bytecode -> workSpace
  227.     mode: op1 0=
  228.     IF
  229.         reg: op1 9 << workSPace or -> workSpace
  230.         ea: op2 workSpace or -> workSpace
  231.         256 workspace or -> workspace
  232.         workSpace w,
  233.     ELSE
  234.         ea: op2 workSpace or -> workSpace
  235.         2048 workspace or -> workSpace
  236.         workSpace w,
  237.         value: op1 w,
  238.     THEN
  239.     op2 compIdxMode
  240. ;M
  241.  
  242. :M LENGTH:    { \ len -- len }
  243.     op1 getOp
  244.     op1 get: srcMask check
  245.     op2 getOp
  246.     op2 get: dstMask check
  247.     mode: op1 0=
  248.     IF
  249.         1 -> len
  250.     ELSE
  251.         2 -> len
  252.     THEN
  253.     len
  254. ;M
  255.  
  256. ;CLASS
  257.  
  258. \ TYPE8 - single ea instructions. E.G. PEA aLabel
  259. :CLASS type8 <super machInst
  260.  
  261. :M BUILD:
  262.     op1 getOp
  263.     get: bytecode ea: op1 or w,
  264.     op1 compIdxMode
  265. ;M
  266.  
  267. :M LENGTH:    { \ len - len }
  268.     op1 getOp
  269.     op1 get: srcMask check
  270.     1 -> len 
  271.     op1 modeSize ++> len
  272.     len
  273. ;M
  274.  
  275. ;CLASS
  276.  
  277. \ TYPE9 - EXG A2,D4
  278. :CLASS type9 <super machInst
  279.  
  280. \ :M BUILD:    { \ work -- }
  281. \     op1 getOp
  282. \     op2 getOp
  283. \     get: bytecode -> work
  284. \     reg: op1 9 << work or -> work
  285. \     reg: op2 work or -> work
  286. \     mode: op1 0= mode: op2 0= and
  287. \     IF
  288. \         64 work or -> work
  289. \     THEN
  290. \     mode: op1 0= mode: op2 1 = and mode: op1 1 = mode: op2 0= and or
  291. \     IF
  292. \         72 work or -> work
  293. \     THEN
  294. \     mode: op1 1 = mode: op2 1 = and
  295. \     IF
  296. \         136 work or -> work
  297. \     THEN
  298. \     work w,
  299. \ ;M
  300.  
  301. :M BUILD:
  302.     op1 getOp
  303.     op2 getOp
  304.     reg: op2    reg: op1
  305.     mode: op1 0=    mode: op2 0=    and
  306.     IF                    \ Both D regs
  307.         $ 40
  308.     ELSE
  309.         mode: op1     mode: op2    and
  310.         IF                \ Both A regs
  311.             $ 48
  312.         ELSE                \ One D, one A
  313.             mode: op1
  314.             IF    ( A is first, but needs to be second )
  315.                 swap
  316.             THEN
  317.             $ 88
  318.         THEN
  319.     THEN
  320.     swap    9 <<    or    or    get: bytecode    or    w,
  321. ;M
  322.  
  323. :M LENGTH: ( -- len )
  324.  
  325.     op1 getOp
  326.     op1 get: srcMask check
  327.     op2 getOp
  328.     op2 get: dstMask check
  329.     1
  330. ;M
  331.  
  332. ;CLASS
  333.  
  334. \ TYPE10 - EXT.L DO
  335. :CLASS type10 <super machInst
  336.  
  337. :M BUILD:    { \ work -- }
  338.     op1 getOp
  339.     get: bytecode -> work
  340.     reg: op1 work or -> work
  341.     opSize 1+    2 max 6 << work or -> work         \ set opMode field
  342.     work w,
  343. ;M
  344.  
  345. :M LENGTH:
  346.     op1 getOp
  347.     op1 get: srcMask check
  348.     1
  349. ;M
  350.  
  351. ;CLASS
  352.  
  353. \ TYPE11 - Shift operations e.g. LSL.W #2,D0
  354. :CLASS type11 <super machInst
  355.  
  356. :M BUILD:    { \ work val -- }
  357.     op1 getOp
  358.     get: bytecode -> work
  359.     mode: op1 11 = mode: op1 0= or
  360.     IF
  361.         opSize 6 << work or -> work
  362.         op2 getOp
  363.         mode: op1 0=
  364.         IF
  365.             32 work or -> work
  366.             reg: op1 9 << work or -> work
  367.         ELSE
  368.             value: op1 -> val
  369.             val 8 mod -> val
  370.             val 9 << work or -> work
  371.         THEN
  372.         reg: op2 work or -> work
  373.         work w,
  374.     ELSE
  375.         192 work or -> work
  376.         ea: op1 work or w,
  377.         op1 compIdxMode
  378.     THEN
  379. ;M
  380.  
  381. :M LENGTH: { \ len -- len }
  382.     op1 getOp
  383.     op1 get: srcMask check
  384.     mode: op1 11 = mode: op1 0= or
  385.     IF
  386.         op2 getOp
  387.         op2 get: dstMask check
  388.         1 -> len
  389.     ELSE
  390.         1 op1 modeSize + -> len
  391.     THEN
  392.     len
  393. ;M
  394.  
  395. ;CLASS
  396.  
  397. \ TYPE12 - ADDQ, SUBQ
  398. \    e.g. ADDQ.L #4,D6
  399. :CLASS type12 <super machInst
  400.  
  401. :M BUILD:    { \ work -- }
  402.     op1 getOp
  403.     op2 getOp
  404.     get: bytecode -> work
  405.     value: op1 8 mod 9 << work or -> work
  406.     opSize 6 << work or -> work
  407.     ea: op2 work or -> work
  408.     work w,
  409.     op2 compIdxMode
  410. ;M
  411.  
  412. :M LENGTH:    ( -- len )
  413.     op1 getOp
  414.     op1 get: srcMask check
  415.     op2 getOp
  416.     op2 get: dstMask check
  417.     1 op2 modeSize +
  418. ;M
  419.  
  420. ;CLASS
  421.  
  422. \ TYPE13 - ABCD, SBCD
  423. \    e.g. ABCD D1,D2 or ABCD -(A4),-(A3)
  424. :CLASS type13 <super machInst
  425.  
  426. :M BUILD:        { \ work -- }
  427.     op1 getOp
  428.     op2 getOp
  429.     get: bytecode -> work
  430.     reg: op1 work or -> work
  431.     reg: op2 9 << work or -> work
  432.     mode: op1 0= not
  433.     IF
  434.         8 ++> work
  435.     THEN
  436.     work w,
  437. ;M
  438.  
  439. :M LENGTH:        { \ len -- len }
  440.     op1 getOp
  441.     op1 get: srcMask check
  442.     op2 getOp
  443.     op2 get: dstMask check
  444.     mode: op1 mode: op2 = not 
  445.     IF
  446.         207 asmError
  447.     THEN
  448.     1 -> len
  449.     op1 modesize ++> len
  450.     op2 modesize ++> len
  451.     len
  452. ;M
  453.  
  454. ;CLASS
  455.